home *** CD-ROM | disk | FTP | other *** search
/ SGI Varsity Update 1998 August / SGI Varsity Update 1998 August.iso / dist / dist6.5 / il_dev.idb / usr / include / il / ilHwPass.h.z / ilHwPass.h
C/C++ Source or Header  |  1998-07-29  |  9KB  |  241 lines
  1. #if 0 
  2.  
  3.     Copyright (c) 1994 SGI   All Rights Reserved
  4.     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF SGI
  5.     The copyright notice above does not evidence any
  6.     actual or intended publication of such source code,
  7.     and is an unpublished work by Silicon Graphics, Inc.
  8.     This material contains CONFIDENTIAL INFORMATION that
  9.     is the property of Silicon Graphics, Inc. Any use,
  10.     duplication or disclosure not specifically authorized
  11.     by Silicon Graphics is strictly prohibited.
  12.     
  13.     RESTRICTED RIGHTS LEGEND:
  14.     
  15.     Use, duplication or disclosure by the Government is
  16.     subject to restrictions as set forth in subdivision
  17.     (c)(1)(ii) of the Rights in Technical Data and Computer
  18.     Software clause at DFARS 52.227-7013, and/or in similar
  19.     or successor clauses in the FAR, DOD or NASA FAR
  20.     Supplement.  Unpublished- rights reserved under the
  21.     Copyright Laws of the United States.  Contractor is
  22.     SILICON GRAPHICS, INC., 2011 N. Shoreline Blvd.,
  23.     Mountain View, CA 94039-7311
  24.  
  25. #endif
  26. /*
  27.     
  28. */
  29.  
  30. #ifndef _ilHwPass_h_
  31. #define _ilHwPass_h_
  32.  
  33. #include <il/ilLink.h>
  34. #include <il/ilHwImg.h>
  35. #include <il/ilFrameBufferImg.h>
  36. #include <ifl/iflClassList.h>
  37.  
  38. class ilNopImg;
  39.  
  40. // OpenGL color description for fill area
  41. struct ilHwFillDesc {
  42.     GLubyte rgb[4];        // r,g,b fill value for parent image
  43.     int ci;            // ci fill value for parent image 
  44.     
  45.     void invert()
  46.     {
  47.     rgb[0] = ~rgb[0]; 
  48.     rgb[1] = ~rgb[1]; 
  49.     rgb[2] = ~rgb[2];
  50.     rgb[3] = ~rgb[3]; 
  51.     }
  52.     
  53.     void negate() 
  54.     {
  55.     rgb[0] = 255-rgb[0]; 
  56.     rgb[1] = 255-rgb[1]; 
  57.     rgb[2] = 255-rgb[2]; 
  58.     rgb[3] = 255-rgb[3]; 
  59.     }
  60.     
  61.     void set(int isRgb=TRUE) const 
  62.     { 
  63.         if (isRgb) 
  64.             glColor4ubv(rgb); 
  65.         else
  66.             glIndexi(ci);
  67.     }
  68. };
  69.  
  70. // ilHwPass encodes the hardware acceleration for an ilImage (or an
  71. // ilImgStat).  A table of ilHwPass instances, one per ilHwConnection/visual
  72. // type combination (encoded via ilHwTarget), is hung off of each ilImage via 
  73. // ilImage::hwPassTable (or ilImgStat::hwPassTable).  The ilHwPass associated 
  74. // with a particular ilHwTarget is retrieved via ilImage::hwGetPass() 
  75. // (or ilImgStat::hwGetPass()).  Calls to hwGetPass() cause ilHwPass's to be 
  76. // created and cached if they don't exist yet.
  77. //
  78. //     N.B. The API for ilImgStat::getPass() does not include an
  79. //          ilHwconnection specification.  As such only one ilHwConnection
  80. //          will ever be in an ilImgStat's hwPassTable.  Some thought is
  81. //          being given to this situation.
  82. //
  83. // An ilHwPass stores pointers to the ilHwTarget it is for (target), 
  84. // its source of image data (inImg), which ilImage (or ilImgStat)
  85. // it's a pass for (via its ilLink parent), and the last ilImage in the 
  86. // pass chain (parentImg).  The ilLink parent and parentImg are the same 
  87. // for ilImage's.  For ilImgStat's, the ilLink parent points at the  
  88. // ilImgStat and parentImg points at the ilImgStat's source ilImage.
  89. //
  90. class ilHwPass : public ilLink {
  91. public:
  92.     iflClassListDeclare
  93.     ilHwPass(ilLink* parent, const ilHwTarget& target);
  94.     virtual ~ilHwPass();
  95.     
  96.     // Setup this ilHwPass for a particular operation, the 'inputIdx'
  97.     // selects which input to use as 'inImg' for polyadic operators,
  98.     // the pass with input index zero is the master and has a list
  99.     // of passes for the remaining inputs; it creates and owns the
  100.     // remaining passes, calling setup, with an appropriate input index,
  101.     // on each of those passes.
  102.     //
  103.     void setup(const ilHwOp& op, int inputIdx=0);
  104.     
  105.     // Query to see if this pass need to be setup
  106.     //
  107.     int needsSetup() { resetCheck(); return setupNeeded; }
  108.  
  109.     // Draw pass's parent image tile (x,y,z, nx,ny,1) at framebuffer
  110.     // location (fx,fy) (all coordinates are in the framebuffer image's
  111.     // orientation (lowerleft, etc.) unless overridden by the config
  112.     // cfg).
  113.     //
  114.     virtual ilStatus drawTile(ilMpNode* parent, 
  115.                   float x, float y, float z, int nx, int ny,
  116.                   ilHwImg* hwImg, int fx, int fy, 
  117.                   int buffEnables=0, ilHwHintList* hints=NULL,
  118.                   ilMpManager** pMgr=NULL);
  119.  
  120.     // Read pass's parent image tile (x,y,z, nx,ny,nz) and place in
  121.     // buffer with coordinates (dx,dy,dz, dnx,dny,dnz).  The attributes
  122.     // are determined by the parent image unless overridden by config.
  123.     //
  124.     virtual ilStatus readTile(ilMpNode* parent, int x, int y, int z, 
  125.                   int nx, int ny, int nz, void*& data, 
  126.                   int dx, int dy, int dz, int dnx, int dny, int dnz, 
  127.                   const ilConfig* cfg, ilMpManager** pMgr=NULL);
  128.  
  129.     // Get statistics for specified channel.  This assumes that a drawTile
  130.     // has been performed with ilHwOpStat selected.
  131.     //
  132.     virtual ilStatus getStat(unsigned long* hist, double& min, double& max, 
  133.                  int chan);
  134.  
  135.     // Return target information associated with this pass: connection,
  136.     // visual class, target ID, whether the pass is on RGB mode, etc.
  137.     //
  138.     ilHwConnection* getConnection() { return target.getConnection(); }
  139.     int getClass() { return target.getClass(); }
  140.     int getID() { return target.getID(); }
  141.     int isRgb() { return target.isRgb(); }
  142.     
  143.     // Return parent/input image.
  144.     //
  145.     ilImage* getParentImg() { return parentImg; }
  146.     ilImage* getInput() { return inImg; }
  147.  
  148.     // Return the last framebuffer image used with this pass
  149.     //
  150.     ilFrameBufferImg* getLastFbImg();
  151.  
  152.     // Set RGB and color index fill values (calculated from parentImg's
  153.     // fill value).
  154.     //
  155.     void setFillColor() { fill.set(isRgb()); }
  156.  
  157.     // return RGB fill value
  158.     //
  159.     const GLubyte* getRgbFill() const { return fill.rgb; }
  160.  
  161.     // Chain on a "related" nop image using given related type
  162.     //
  163.     static ilNopImg* getNopImg(ilImage* img, int rtype);
  164.     
  165.     // Chain on a "related" nop image using default related type (depricated)
  166.     //
  167.     static ilNopImg* getNopImg(ilImage* img);
  168.  
  169. protected:
  170.     // Check validity of an operation, called from setup after parent
  171.     // and input image are filled in, the input index is used to
  172.     // distinguish the 'master' pass (index 0) from the slave passes 
  173.     // (index > 0).
  174.     //
  175.     virtual void checkOp(const ilHwOp& op, int inputIdx) = 0;
  176.     
  177.     // Copy another hardware pass's parameters onto ourself.  For this
  178.     // base class the only thing that needs to be copied is inImg.
  179.     void copy(ilHwPass* pass) { inImg = origInImg = pass->origInImg; }
  180.  
  181.     // Update the last framebuffer image used with this pass
  182.     //
  183.     void updateLastFbImg(ilFrameBufferImg* fbImg);
  184.  
  185.     // compute appropriate fill value (based on parent image and 
  186.     // our visual). 
  187.     //
  188.     void calcFill(ilHwFillDesc& fillDesc, ilImage* img, int transparent=FALSE);
  189.     
  190.     // determine what the h/w supports on this visual
  191.     // 
  192.     void calcCapabilities(); 
  193.     
  194.     // returns TRUE if the input is a related image, but is not a color
  195.     // image that was allocated by ilOpImg.  The pass cannot alter any
  196.     // image that can affect the application chain (including the pass'
  197.     // parent)
  198.     //
  199.     int canAlterInput(ilImage* input=NULL);
  200.     
  201.     // Pixel operations (DrawPixel/SubtextureLoad) supported by hardware
  202.     // for the visual that we are using.  These methods must not be called
  203.     // before calling calcCapabilites().
  204.     //
  205.     int doesRGB()        { return capabilities & ilHwCapCvtRGB; }
  206.     int doesLuminance()        { return capabilities & ilHwCapCvtLuminance; }
  207.     int doesScale()        { return capabilities & ilHwCapScaleBias; }
  208.     int doesZoom()        { return capabilities & ilHwCapZoom; }
  209.     int doesFracZoom()        { return capabilities & ilHwCapFracZoom; }
  210.     int doesTexture()        { return capabilities & ilHwCapTexture; }
  211.     int doesConvolve()        { return capabilities & ilHwCapConvolve; }
  212.     int doesBlendColor()    { return capabilities & ilHwCapBlendColor; }
  213.     int doesBlendLogicOp()    { return capabilities & ilHwCapBlendLogicOp; }
  214.     int doesColorMatrix()    { return capabilities & ilHwCapColorMatrix; }
  215.     
  216.     // reset just sets the setupNeeded flag
  217.     virtual void reset();
  218.  
  219.     ilHwTarget target;        // target for this pass (dpy/visual)
  220.     ilImage* parentImg;        // parent image, last element in pass's chain
  221.     ilImage* inImg;        // input image, first element in pass's chain
  222.     ilImage* origInImg;        // input image before any converters are applied
  223.     ilHwFillDesc fill;        // parent image fill descriptor
  224.     int capabilities;        // capabilities for pass (a modified copy of the
  225.                 //   related ilHwConnection's "capability" with
  226.                 //   modifications based on target's visualClass)
  227.     int setupNeeded;        // if TRUE, pass needs to be setup
  228. };
  229.  
  230.  
  231. inline int
  232. ilHwCanAlter(ilImage* input)
  233. {
  234.     extern iflName* ilInheritColorConvID;
  235.     return input->isRelated() && 
  236.     (!input->isColorImg() || ilInheritColorConvID == NULL || 
  237.      !input->getProp(ilInheritColorConvID));
  238. }
  239.  
  240. #endif
  241.